package com.ysd.twocrm.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ysd.twocrm.entity.*;
import com.ysd.twocrm.mapper.ModulesMapper;
import com.ysd.twocrm.mapper.PermissionMapper;
import com.ysd.twocrm.mapper.RoleModulesMapper;
import com.ysd.twocrm.service.ModulesService;
import com.ysd.twocrm.utils.UUID;
import org.apache.ibatis.annotations.Delete;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@CrossOrigin
@RestController
@RequestMapping("modules")
public class ModulesController {
    @Autowired
    private ModulesService modulesService;
    @Autowired
    private ModulesMapper modulesMapper;
    @Autowired
    private RoleModulesMapper roleModulesMapper;
    @Autowired
    private PermissionMapper permissionMapper;
    /*
     * @Description 获取当前用户所拥有的模块，父节点---子节点
     * @param userId 用户id
     * @return java.lang.Object
     * @author liusupeng
     * @date 2020/4/9 10:54
     */
    @GetMapping
    public  Object getAllTree(Integer userId){

        return modulesService.getTreeNode(userId);
    }
    /*
     * @Description layui tree要的节点
     * @param
     * @return java.lang.Object
     * @author liusupeng
     * @date 2020/4/15 15:38
     */
    @GetMapping("/1")
    public Object getAllTreeOne(){


        return modulesService.getTreeNodeOne();
    }
    /*
     * @Description 用于查询当前角色下的全部模块，但是除了父id，因为这个是在前台layui的tree渲染的，所以不能有父id
     * @param roleId
     * @return java.lang.Object
     * @author liusupeng
     * @date 2020/4/15 15:37
     */
    @GetMapping("/2")
    public Object getAllTreeRolesByMid(Integer roleId){


        return modulesMapper.findModulesIdByRolesId(roleId);
    }
    /*
     * @Description 根据模块id来查询当前模块的信息
     * @param id
     * @return java.lang.Object
     * @author liusupeng
     * @date 2020/4/16 8:54
     */

    @GetMapping("/3")
    public Object getAllModulesById(Integer id){

        return  modulesMapper.selectById(id);
    }
    /*
     * @Description 判断名称是否存在
     * @param modulesName
     * @return java.lang.Object
     * @author liusupeng
     * @date 2020/4/16 11:19
     */
    @GetMapping("/4")
    public Object getAllIfModulesName(String modulesName){

        Modules modulesByMname = modulesMapper.findModulesByMname(modulesName);
        if(!StringUtils.isEmpty(modulesByMname)){
            return "falsename";
        }
        return "true";
    }

    /*
     * @Description 查找全部角色权限
     * @param
     * @return
     * @author liusupeng
     * @date 2020/4/18 16:20
     */
    @GetMapping("/5")
    @RequiresPermissions(value = "roles:permission")
    public Object getAllPermissionTree(Integer roleId){
        List<ModulesTree> treePermission = modulesService.getLayuiPermmion();//全部权限
        List<RolesPermission> rolesPermissions = permissionMapper.findpermissionIdByRoleId(roleId);//当前用户所拥有的权限
        for(int i=0;i<rolesPermissions.size();i++){
            for(ModulesTree mt:treePermission){
                if(mt.getChildren()!=null){
                    for(ModulesTree mt1:mt.getChildren()){
                        if(mt1.getChildren()!=null){
                            for(ModulesTree mt2:mt1.getChildren()){
                              if(rolesPermissions.get(i).getPermissionId().equals(mt2.getId())){
                                  System.out.println(mt2);
                                  mt2.setChecked(true);
                              }
                            }
                        }
                    }
                }
            }
        }



        return treePermission;
    }


    /*
     * @Description 添加模块
     * 如果添加的子模块，会向权限表里也添加一条信息
     * @param m
     * @return java.lang.String
     * @author liusupeng
     * @date 2020/4/16 10:40
     *
     */
    @PostMapping
    public String addModules(Modules m){


            int insert = modulesMapper.insert(m);
            if(insert>0){
              if(m.getModulesParentId()!=0){
                  String checkUUID = (String) UUID.createCheckUUID();
                  Permission ps=new Permission(checkUUID,"all",m.getModulesName(),"全部操作",new Date());
                  permissionMapper.insert(ps);
              }
                return "success";
            }


        return "false";
    }
    /*
     * @Description 根据姓名先查询当前模块名称是否存在，如果存在则返回false，不存在，则修改
     * 如果要修改的话也要去修改权限表里的
     * @param modulesName
     * @param modulesId
     * @return java.lang.String
     * @author liusupeng
     * @date 2020/4/16 13:30
     */
    @PutMapping
    public String exitMoodulesSetNameById(String modulesName,Integer modulesId){

        Modules modulesByMname = modulesMapper.findModulesByMname(modulesName);
        if(StringUtils.isEmpty(modulesByMname)){
            //先根据模块id去查当前模块的名称
            QueryWrapper<Modules> queryWrappermodules=new QueryWrapper();
            queryWrappermodules.eq("modulesId",modulesId);
            Modules modulespermission = modulesMapper.selectOne(queryWrappermodules);

            Integer integer = modulesMapper.exitModulesByIdSetName(modulesName, modulesId);
            if(integer>0){
                permissionMapper.exitPermissionByName(modulesName,modulespermission.getModulesName());
                return "success";
            }

        }
        return "false";
    }
    /*
     * @Description 首先根据当前的父id去查询当前父id的模块
     * 这时拿到了当前父id模块的父id然后将这个父id修改成原本的那个父id
     * 当然每次升级的时候都会将自己下面的权限信息删除
     * @param modulesId
     * @param modulesParentId
     * @return java.lang.String
     * @author liusupeng
     * @date 2020/5/13 13:20
     */
@PutMapping("/1")
    public String exitModulesByModulesId(Integer modulesId,Integer modulesParentId ){


    System.out.println(modulesId);
    System.out.println(modulesParentId);

    QueryWrapper queryWrapper=new QueryWrapper();
        queryWrapper.eq("modulesId",modulesParentId);
    Modules modules = modulesMapper.selectOne(queryWrapper);

    Integer integer = modulesMapper.exitModulesByMid(modulesId, modules.getModulesParentId());
          if(integer>0){
              //先根据模块id去查当前模块的名称
              QueryWrapper<Modules> queryWrappermodules=new QueryWrapper();
              queryWrappermodules.eq("modulesId",modulesId);
              Modules modulespermission = modulesMapper.selectOne(queryWrappermodules);
              //创建删除的条件
              QueryWrapper<Permission> permissionQueryWrapper=new QueryWrapper<>();
              permissionQueryWrapper.eq("permissionModule",modulespermission.getModulesName());
              //删除条件
              permissionMapper.delete(permissionQueryWrapper);
              return "success";
          }
    return "false";
    }


    /*
     * @Description 根据id去查找当前模块下是否有子类，如果有则返回false，没有则删除
     * 删除的时候也会删除角色模块表也会删除对应的权限表
     * @param modulesId
     * @return java.lang.String
     * @author liusupeng
     * @date 2020/4/16 12:07
     */
    @DeleteMapping
    public String delModules(Integer modulesId,String modulesName){


        List<Modules> modulesById = modulesMapper.findModulesById(modulesId);
        if(modulesById.isEmpty()){
                modulesMapper.deleteById(modulesId);
            roleModulesMapper.delModulesByMid(modulesId);
                        //创建删除的条件
            QueryWrapper<Permission> permissionQueryWrapper=new QueryWrapper<>();
            permissionQueryWrapper.eq("permissionModule",modulesName);
            //删除条件
            System.out.println(modulesName+"<==============");
            permissionMapper.delete(permissionQueryWrapper);
            return "success";
        }
        return "false";
    }
}
